package Review;

import java.util.*;

public class Text4 {
    public static void main(String[] args) {
        //底层是一个双向链表
        Deque<Integer> deque = new LinkedList<>();
        //数组实现的双端队列：底层就是一个数组
        Deque<Integer> deque1 = new ArrayDeque<>();
        //顺序的双端队列也可以当作栈来使用
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);//顺序的双端队列（底层是用数组来实现的）也提供了栈的相关的方法

    }
    public static void main8(String[] args) {
        //双端队列
        Deque<Integer> deque = new LinkedList<>();
        //普通队列
        //Queue中既有offer方法，也有add方法，add在无法添加一个元素时，会抛出一个异常
        //offer方法优于add方法，如果无法添加元素，offer方法不会抛出异常
        Queue<Integer> queue = new LinkedList<>();
        //链式栈  虽然是具体的类但是里面有栈的方法
        //LinkedList类中的方法是最多的，因为它实现了很多接口，此时一定会重写接口中的方法
        LinkedList<Integer> stack = new LinkedList<>();
        //双向链表
        List<Integer> list = new LinkedList<>();
        //其他的都是使用接口来引用的：只有接口中的方法
    }
    public static void main7(String[] args) {
        /*此时是可以用单链表或者是双链表实现一个队列的，如果用单链表实现一个队列
        * 此时需要记录一个最后的节点否则在插入或者删除的时候一定有一个复杂度是O(N)的
        * 如果用双链表实现一个队列，插入和删除的时间复杂度都是O(1)，
        * 如果用数组实现一个队列，插入和删除操作同时进行的时候发现数组的空间利用的并不是很好
        * 所以就引出了循环队列这种结构，设计循环队列就又有两个问题，rear下标如何到0（开始）的下标
        * 2.到了开始的下标之后first和rear指向的都是0下标，此时是空还是满？*/
        Queue<Integer> queue = new LinkedList<>();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        queue.offer(4);
        queue.offer(5);
        System.out.println(queue.peek());
        System.out.println(queue.poll());
        System.out.println(queue.peek());
    }
    public static void main6(String[] args) {
        //尾插法和头部删除
        MyQueue queue = new MyQueue();
        queue.offer(1);
        queue.offer(2);
        queue.offer(3);
        System.out.println(queue.peek());//1
        System.out.println(queue.poll());//1
        System.out.println(queue.peek());
    }
    public static void main5(String[] args) {
        //也可以用双向链表来当作栈使用，如果是一个单链表，此时是无法从头部插入
        //并且在头部进行删除的，但是双链表是可以的，刚好LinkedList底层刚好
        //是一个双链表
        LinkedList<Integer> stack = new LinkedList<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        System.out.println(stack.pop());
        System.out.println(stack.peek());
        //Stack本身这个栈是顺序栈，底层是一个数组
    }
    public static void main4(String[] args) {
        MySingleList list = new MySingleList();
        list.addLast(1);
        list.addLast(2);
        list.addLast(3);
        list.addLast(4);
        list.display3(list.head);
        System.out.println();
        list.display4();
    }
    public static void main3(String[] args) {
        MyStack stack = new MyStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        Integer a = stack.pop();
        System.out.println(a);//3
        Integer b = stack.peek();
        System.out.println(b);//2
        System.out.println(stack.size());//2
        //isEmpty这个方法是从Vector继承来的
        System.out.println(stack.isEmpty());//false
    }
    public static void main1(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        Integer a = stack.pop();
        System.out.println(a);//3
        Integer b = stack.peek();
        System.out.println(b);//2
        System.out.println(stack.size());//2
        //isEmpty这个方法是从Vector继承来的
        System.out.println(stack.isEmpty());//false
    }
}
